import javax.swing.*;                        // 导入Swing组件库，用于创建图形界面
import javax.sound.sampled.*;                // 导入音频处理库，用于播放按键音效
import java.awt.*;                          // 导入AWT库，提供基本图形和界面功能
import java.awt.event.*;                    // 导入事件处理库，处理用户交互事件
import java.awt.geom.RoundRectangle2D;      // 导入几何图形类，用于圆角绘制
import java.io.File;                        // 导入文件类，用于文件操作
import java.io.IOException;                 // 导入IO异常类，处理文件操作异常
import java.net.URL;                        // 导入URL类，用于资源加载
import java.time.LocalDateTime;             // 导入日期时间类，用于显示时间
import java.time.format.DateTimeFormatter;  // 导入日期格式化类，用于时间格式转换
import javax.script.ScriptEngine;           // 导入脚本引擎接口，用于表达式计算
import javax.script.ScriptEngineManager;    // 导入脚本引擎管理器，用于创建脚本引擎
import javax.script.ScriptException;        // 导入脚本异常类，处理计算异常
import java.util.HashMap;                   // 导入HashMap类，用于存储音效
import java.util.Map;                       // 导入Map接口，定义键值对集合
import java.util.Timer;                     // 导入定时器类
import java.util.TimerTask;                 // 导入定时任务类

public class Calculator extends JFrame {    // Calculator: 计算器类名，继承JFrame窗口类
    // 界面组件声明
    private JTextField displayField;                // displayField: 显示计算结果的文本框
    private JButton[] mainButtons;                  // mainButtons: 标准模式按钮数组
    private JButton[] scientificButtons;            // scientificButtons: 科学模式按钮数组
    private JPanel mainPanel, scientificPanel, displayPanel; // 不同功能的面板组件
    private boolean isScientificMode = false;       // isScientificMode: 模式切换标志，默认false(标准模式)
    
    // 界面样式定义
    private Color primaryColor = new Color(26, 115, 232);    // primaryColor: 主色调(蓝色)
    private Color secondaryColor = new Color(241, 243, 244); // secondaryColor: 辅助色(浅灰)
    private Color accentColor = new Color(255, 102, 0);     // accentColor: 强调色(橙色)
    private Font buttonFont = new Font("Segoe UI", Font.BOLD, 24); // buttonFont: 按钮字体
    private Font displayFont = new Font("Segoe UI", Font.BOLD, 40); // displayFont: 显示字体
    
    // 音效系统成员
    private Map<String, Clip> soundClips = new HashMap<>();     // soundClips: 存储音效的映射表
    private String currentSound = "custom";                     // currentSound: 当前使用的音效类型
    
    // 背景图片相关
    private Image backgroundImage = null;                       // backgroundImage: 背景图片对象
    private final String BACKGROUND_PATH = "D:\\Desk\\见习2\\微信图片_20250628155218.jpg"; // 背景图片路径
    
    // 按钮文本定义
    private final String[] MAIN_BUTTONS = {                     // MAIN_BUTTONS: 标准模式按钮数组
        "7", "8", "9", "+",
        "4", "5", "6", "-",
        "1", "2", "3", "×",
        "0", ".", "=", "÷",
        "C", "B", "T", "S"
    };
    
    private final String[] SCIENTIFIC_BUTTONS = {               // SCIENTIFIC_BUTTONS: 科学模式按钮文本数组
        "sin", "cos", "tan", "π",
        "log", "ln", "√", "e",
        "(", ")", "x²", "1/x",
        "%", "!", "Rand", "S"
    };
    
    // 时间显示相关成员
    private Timer timer;                      // 定时器对象
    private boolean isShowingTime = false;    // 是否正在显示时间的标志

    public Calculator() {                                       // Calculator: 构造函数，初始化计算器
        initUI();                                               // initUI: 初始化用户界面
        setupAudio();                                           // setupAudio: 初始化音效系统
        startClock();                                           // 启动时钟
    }

    private void initUI() {                                     // initUI: 初始化用户界面方法
        setTitle("高级计算器");                                  // setTitle: 设置窗口标题
        setSize(700, 700);                                      // setSize: 设置窗口大小
        setDefaultCloseOperation(EXIT_ON_CLOSE);                // setDefaultCloseOperation: 设置关闭操作
        setLocationRelativeTo(null);                            // setLocationRelativeTo: 窗口居中显示
        setResizable(false);                                    // setResizable: 禁止调整窗口大小
        
        // 加载背景图片
        loadBackgroundImage();
        
        // 设置背景面板（匿名内部类重写绘图方法）
        setContentPane(new JPanel(new BorderLayout()) {
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);                        // super.paintComponent: 调用父类绘图方法
                Graphics2D g2d = (Graphics2D) g;                // Graphics2D: 2D图形上下文
                g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); // 设置图像插值为双线性，使缩放更平滑
                
                // 绘制背景图片或渐变背景
                if (backgroundImage != null) {
                    g2d.drawImage(backgroundImage, 0, 0, getWidth(), getHeight(), this); // drawImage: 绘制背景图片
                } else {
                    // 绘制渐变背景
                    GradientPaint gp = new GradientPaint(
                        0, 0, new Color(240, 240, 240),
                        0, getHeight(), new Color(220, 220, 220));
                    g2d.setPaint(gp);                           // setPaint: 设置绘图填充
                    g2d.fillRect(0, 0, getWidth(), getHeight()); // fillRect: 填充矩形区域
                }
            }
        });

        // 初始化显示面板
        displayPanel = new JPanel(new BorderLayout());          // displayPanel: 显示面板，使用边框布局
        displayPanel.setOpaque(false);                          // setOpaque: 设置面板透明
        displayPanel.setBorder(BorderFactory.createEmptyBorder(20, 20, 10, 20)); // setBorder: 设置边框空白
        
        displayField = new JTextField();                        // displayField: 显示文本框
        displayField.setFont(displayFont);                      // setFont: 设置字体
        displayField.setHorizontalAlignment(JTextField.RIGHT);   // setHorizontalAlignment: 文本右对齐
        displayField.setEditable(false);                        // setEditable: 禁止编辑
        displayField.setBackground(new Color(255, 255, 255, 180)); // setBackground: 设置半透明白色背景
        displayField.setBorder(BorderFactory.createCompoundBorder( // setBorder: 设置复合边框
            BorderFactory.createLineBorder(new Color(200, 200, 200), 1), // createLineBorder: 细线边框
            BorderFactory.createEmptyBorder(10, 15, 10, 15)      // createEmptyBorder: 内部空白
        ));
        displayField.setPreferredSize(new Dimension(680, 120));  // setPreferredSize: 设置首选大小
        
        // 设置圆角文本框UI（匿名内部类重写UI）
        displayField.setUI(new javax.swing.plaf.basic.BasicTextFieldUI() {
            @Override
            protected void installDefaults() {
                super.installDefaults();                          // 调用父类方法
                getComponent().setOpaque(false);                   // setOpaque: 设置组件透明
            }
        });
        
        displayPanel.add(displayField, BorderLayout.CENTER);     // add: 将文本框添加到面板中心
        
        // 创建按钮面板
        mainPanel = createButtonPanel(MAIN_BUTTONS);            // mainPanel: 标准模式按钮面板
        scientificPanel = createButtonPanel(SCIENTIFIC_BUTTONS); // scientificPanel: 科学模式按钮面板

        // 添加菜单栏
        createMenuBar();

        // 组装界面
        add(displayPanel, BorderLayout.NORTH);                   // add: 添加显示面板到北部
        add(mainPanel, BorderLayout.CENTER);                     // add: 添加按钮面板到中心
        
        setVisible(true);                                       // setVisible: 显示窗口
    }

    // 加载背景图片方法
    private void loadBackgroundImage() {
        try {
            File imageFile = new File(BACKGROUND_PATH);           // File: 文件对象
            if (imageFile.exists()) {                            // exists: 检查文件是否存在
                backgroundImage = new ImageIcon(BACKGROUND_PATH).getImage(); // ImageIcon: 加载图片
                System.out.println("背景图片加载成功: " + BACKGROUND_PATH); // 打印成功信息
            } else {
                System.err.println("背景图片不存在: " + BACKGROUND_PATH); // 打印错误信息
                System.err.println("使用默认渐变背景");
            }
        } catch (Exception e) {                                  // Exception: 捕获所有异常
            System.err.println("加载背景图片失败: " + e.getMessage()); // 打印异常信息
            backgroundImage = null;                               // 设置图片为null
        }
    }

    private void createMenuBar() {                              // createMenuBar: 创建菜单栏方法
        JMenuBar menuBar = new JMenuBar();                      // JMenuBar: 菜单栏组件
        JMenu optionsMenu = new JMenu("选项");                    // JMenu: 菜单组件
        JMenu soundMenu = new JMenu("音效");                      // JMenu: 子菜单组件
        JRadioButtonMenuItem customSound = new JRadioButtonMenuItem("自定义音效"); // JRadioButtonMenuItem: 单选菜单项
        
        customSound.setSelected(true);                           // setSelected: 设置默认选中
        customSound.addActionListener(e -> currentSound = "custom"); // addActionListener: 选择音效事件
        
        soundMenu.add(customSound);                             // add: 添加到音效菜单
        optionsMenu.add(soundMenu);                             // add: 添加到选项菜单
        menuBar.add(optionsMenu);                               // add: 添加到菜单栏
        setJMenuBar(menuBar);                                   // setJMenuBar: 设置菜单栏
    }

    private JPanel createButtonPanel(String[] buttonTexts) {     // createButtonPanel: 创建按钮面板方法
        JPanel panel = new JPanel(new GridLayout(5, 4, 10, 10)); // GridLayout: 5行4列网格布局
        panel.setOpaque(false);                                  // setOpaque: 设置面板透明
        panel.setBorder(BorderFactory.createEmptyBorder(10, 20, 20, 20)); // setBorder: 设置边框空白
        
        JButton[] buttons = new JButton[buttonTexts.length];     // JButton: 按钮数组
        for (int i = 0; i < buttonTexts.length; i++) {           // 循环创建按钮
            final int index = i;                                  // index: 按钮索引
            final String buttonText = buttonTexts[i];             // buttonText: 按钮文本
            
            buttons[i] = new JButton(buttonText);                 // JButton: 创建按钮
            buttons[i].setFont(buttonFont);                       // setFont: 设置字体
            buttons[i].setFocusPainted(false);                    // setFocusPainted: 不绘制焦点
            buttons[i].setContentAreaFilled(false);               // setContentAreaFilled: 不填充内容区域
            buttons[i].setOpaque(true);                           // setOpaque: 设置不透明
            
            // 设置按钮样式
            if (buttonText.equals("=") || buttonText.equals("C")) { // 等号和清除按钮
                buttons[i].setBackground(accentColor);            // setBackground: 橙色背景
                buttons[i].setForeground(Color.WHITE);            // setForeground: 白色前景
            } else if (buttonText.equals("S") || buttonText.equals("T") || buttonText.equals("B")) { // 功能按钮
                buttons[i].setBackground(primaryColor);           // setBackground: 蓝色背景
                buttons[i].setForeground(Color.WHITE);            // setForeground: 白色前景
            } else if (index % 4 == 3) {                          // 运算符按钮（每4个中的第4个）
                buttons[i].setBackground(secondaryColor);         // setBackground: 浅灰背景
                buttons[i].setForeground(primaryColor);           // setForeground: 蓝色前景
            } else {                                              // 数字按钮
                buttons[i].setBackground(new Color(255, 255, 255, 180)); // setBackground: 半透明白色背景
                buttons[i].setForeground(Color.BLACK);            // setForeground: 黑色前景
            }
            
            // 设置按钮形状和交互效果
            buttons[i].setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); // setBorder: 设置边框空白
            buttons[i].setPreferredSize(new Dimension(100, 100)); // setPreferredSize: 设置首选大小
            
            // 添加鼠标交互动画
            buttons[i].addMouseListener(new MouseAdapter() {
                @Override
                public void mouseEntered(MouseEvent e) {          // mouseEntered: 鼠标进入事件
                    JButton btn = (JButton) e.getSource();        // getSource: 获取触发事件的按钮
                    btn.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR)); // setCursor: 设置手型光标
                    btn.setForeground(new Color(255, 255, 255));  // setForeground: 设置白色前景
                    btn.setBackground(btn.getBackground().darker()); // setBackground: 背景色变深
                }
                
                @Override
                public void mouseExited(MouseEvent e) {           // mouseExited: 鼠标离开事件
                    JButton btn = (JButton) e.getSource();        // getSource: 获取触发事件的按钮
                    // 恢复按钮背景颜色
                    if (btn.getText().equals("=") || btn.getText().equals("C")) {
                        btn.setBackground(accentColor);
                    } else if (btn.getText().equals("S") || btn.getText().equals("T") || 
                              btn.getText().equals("B")) {
                        btn.setBackground(primaryColor);
                    } else if (index % 4 == 3) {
                        btn.setBackground(secondaryColor);
                        btn.setForeground(primaryColor);
                    } else {
                        btn.setBackground(new Color(255, 255, 255, 180));
                        btn.setForeground(Color.BLACK);
                    }
                }
                
                @Override
                public void mousePressed(MouseEvent e) {          // mousePressed: 鼠标按下事件
                    JButton btn = (JButton) e.getSource();        // getSource: 获取触发事件的按钮
                    btn.setSize(btn.getWidth() - 4, btn.getHeight() - 4); // setSize: 缩小按钮
                    btn.setLocation(btn.getX() + 2, btn.getY() + 2); // setLocation: 移动按钮位置
                    playButtonSound();                            // playButtonSound: 播放音效
                }
                
                @Override
                public void mouseReleased(MouseEvent e) {         // mouseReleased: 鼠标释放事件
                    JButton btn = (JButton) e.getSource();        // getSource: 获取触发事件的按钮
                    btn.setSize(btn.getWidth() + 4, btn.getHeight() + 4); // setSize: 恢复按钮大小
                    btn.setLocation(btn.getX() - 2, btn.getY() - 2); // setLocation: 恢复按钮位置
                }
            });
            
            // 添加按钮点击事件
            buttons[i].addActionListener(e -> {
                JButton source = (JButton) e.getSource();         // getSource: 获取触发事件的按钮
                processButtonClick(source.getText());             // processButtonClick: 处理按钮点击
            });
            
            panel.add(buttons[i]);                               // add: 将按钮添加到面板
        }
        
        return panel;                                           // 返回按钮面板
    }

    // 以下为计算功能相关方法（修复负数乘法和小数运算）
    private void processButtonClick(String buttonText) {        // 处理按钮点击事件
        switch (buttonText) {                                   // 根据按钮文本执行不同操作
            case "C": clearDisplay(); break;                    // 清除显示
            case "B": backspace(); break;                       // 退格
            case "T": toggleClock(); break;                     // 切换时钟显示
            case "S": toggleScientificMode(); break;            // 切换模式
            case "=": evaluateExpression(); break;              // 计算表达式
            case "π": appendConstant("π"); break;               // 插入圆周率
            case "e": appendConstant("e"); break;               // 插入自然常数
            case "x²": calculateSquare(); break;                // 计算平方
            case "1/x": calculateReciprocal(); break;           // 计算倒数
            case "√": calculateSquareRoot(); break;             // 计算平方根
            case "Rand": generateRandom(); break;               // 生成随机数
            case "!": calculateFactorial(); break;              // 计算阶乘
            // 三角函数和对数函数
            case "sin": case "cos": case "tan": case "log": case "ln": 
                appendFunction(buttonText); break;              // 追加函数
            default:                                            // 数字、小数点、运算符
                if (isOperator(buttonText)) {
                    appendOperator(buttonText);                 // 追加运算符
                } else if (buttonText.equals(".")) {
                    appendDecimal();                            // 追加小数点
                } else {
                    appendNumber(buttonText);                   // 追加数字
                }
                break;
        }
    }

    private void appendNumber(String number) {                  // 追加数字到显示
        if (isShowingTime) {
            clearDisplay();
            isShowingTime = false;
        }
        displayField.setText(displayField.getText() + number);
    }
    
    // 修复负数处理的运算符追加方法
    private void appendOperator(String operator) {
        if (isShowingTime) {
            clearDisplay();
            isShowingTime = false;
        }
        
        String current = displayField.getText();                // 获取当前显示内容
        
        // 特殊处理负号作为一元运算符的情况
        if (operator.equals("-")) {
            // 如果表达式为空，添加负号作为一元运算符
            if (current.isEmpty()) {
                displayField.setText("-");
                return;
            }
            
            char lastChar = current.charAt(current.length() - 1);
            // 如果最后一个字符是运算符或左括号，添加负号作为一元运算符
            if (isOperator(lastChar) || lastChar == '(') {
                displayField.setText(current + "-");
                return;
            }
        }
        
        // 防止连续输入运算符（除了上面处理的负号情况）
        if (!current.isEmpty() && isOperator(current.charAt(current.length() - 1))) {
            return;
        }
        
        displayField.setText(current + operator);               // 追加运算符
    }

    private void appendDecimal() {                             // 小数点处理
        if (isShowingTime) {
            clearDisplay();
            isShowingTime = false;
        }
        
        String current = displayField.getText();                // 获取当前显示内容
                
        if (current.isEmpty()) {
            displayField.setText("0.");                        // 空时添加0.
            return;
        }
        
        char lastChar = current.charAt(current.length() - 1);  // 获取最后一个字符
        
        if (isOperator(lastChar) || lastChar == '(') {
            displayField.setText(current + "0.");                // 运算符后自动补0
            return;
        }
        
        // 只检查当前数字部分是否已有小数点
        String currentNumber = getCurrentNumber(current);
        if (!currentNumber.contains(".")) {
            displayField.setText(current + ".");
        }
    }

    // 获取当前正在输入的数字部分（从最后一个运算符之后开始）
    private String getCurrentNumber(String expression) {
        int lastOperatorIndex = -1;                             // 初始化最后一个运算符索引
        for (int i = expression.length() - 1; i >= 0; i--) {    // 从后向前遍历表达式
            char c = expression.charAt(i);
            if (isOperator(c) || c == '(' || c == ')') {
                // 跳过括号内的运算符
                if (c == ')') {
                    int parenCount = 1;
                    i--;
                    while (i >= 0 && parenCount > 0) {
                        c = expression.charAt(i);
                        if (c == ')') parenCount++;
                        if (c == '(') parenCount--;
                        i--;
                    }
                    continue;
                }
                lastOperatorIndex = i;
                break;
            }
        }
        return lastOperatorIndex == -1 ? expression : expression.substring(lastOperatorIndex + 1);
    }

    private void appendConstant(String constant) {             // 追加常数
        if (isShowingTime) {
            clearDisplay();
            isShowingTime = false;
        }
        
        String current = displayField.getText();                // 获取当前显示内容
        if (!current.isEmpty() && !isOperator(current.charAt(current.length() - 1))) {
            displayField.setText(current + "*" + constant);      // 非运算符后添加乘号
        } else {
            displayField.setText(current + constant);           // 直接添加常数
        }
    }

    private void clearDisplay() {                              // 清除显示
        isShowingTime = false;
        displayField.setText("");                               // 设置显示文本为空
    }
    
    private void backspace() {                                 // 退格删除
        if (isShowingTime) {
            clearDisplay();
            isShowingTime = false;
            return;
        }
        
        String current = displayField.getText();                // 获取当前显示内容
        if (!current.isEmpty()) {
            displayField.setText(current.substring(0, current.length() - 1)); // 删除最后一个字符
        }
    }

    private void showTime() {                                  // 显示当前时间
        LocalDateTime now = LocalDateTime.now();               // 获取当前日期时间
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); // 创建日期格式化器
        displayField.setText(now.format(formatter));            // 格式化并显示时间
    }

    private void toggleScientificMode() {                      // 切换标准/科学模式
        isShowingTime = false;
        isScientificMode = !isScientificMode;                  // 切换模式标志
        remove(mainPanel);                                      // 从界面移除标准模式面板
        remove(scientificPanel);                                // 从界面移除科学模式面板
        
        if (isScientificMode) {
            add(scientificPanel, BorderLayout.CENTER);          // 添加科学模式面板
            setTitle("科学计算器");                              // 修改窗口标题为科学计算器
        } else {
            add(mainPanel, BorderLayout.CENTER);                // 添加标准模式面板
            setTitle("高级计算器");                              // 修改窗口标题为高级计算器
        }
        
        revalidate();                                           // 重新验证布局
        repaint();                                              // 重绘界面
    }

    private void evaluateExpression() {                        // 计算表达式结果
        isShowingTime = false;
        String expression = displayField.getText();              // 获取当前显示的表达式
        expression = replaceMathFunctions(expression);          // 替换数学函数为JavaScript可识别格式
        
        // 验证表达式格式
        if (!validateExpression(expression)) {
            displayField.setText("计算错误");
            return;
        }
        
        ScriptEngineManager manager = new ScriptEngineManager(); // 创建脚本引擎管理器
        ScriptEngine engine = manager.getEngineByName("JavaScript"); // 获取JavaScript脚本引擎
        
        try {
            // 调试输出转换后的表达式
            System.out.println("计算表达式: " + expression);
            Object result = engine.eval(expression);             // 执行表达式计算
            displayField.setText(result.toString());             // 显示计算结果
        } catch (ScriptException ex) {
            displayField.setText("计算错误");
            ex.printStackTrace(); // 打印异常信息用于调试
        }
    }

    // 改进的表达式验证，支持负数
    private boolean validateExpression(String expr) {
        // 允许表达式以一元负号开头
        if (expr.startsWith("-")) {
            expr = expr.substring(1);
        }
        
        // 检查双小数点
        if (expr.matches(".*\\.\\..*")) return false;
        
        // 检查括号匹配
        int parenCount = 0;
        for (char c : expr.toCharArray()) {
            if (c == '(') parenCount++;
            if (c == ')') parenCount--;
            if (parenCount < 0) return false;
        }
        if (parenCount != 0) return false;
        
        return true;
    }

    private String replaceMathFunctions(String expression) {    // 替换计算符号和函数
        // 替换乘除符号和常数
        expression = expression.replace("×", "*")               // 将×替换为*
                               .replace("÷", "/")               // 将÷替换为/
                               .replace("π", String.valueOf(Math.PI)) // 将π替换为Math.PI
                               .replace("e", String.valueOf(Math.E)); // 将e替换为Math.E
        
        // 替换三角函数和对数函数
        expression = expression.replace("sin(", "Math.sin(Math.toRadians(") // 将sin(替换为Math.sin(Math.toRadians(
                               .replace("cos(", "Math.cos(Math.toRadians(") // 将cos(替换为Math.cos(Math.toRadians(
                               .replace("tan(", "Math.tan(Math.toRadians(") // 将tan(替换为Math.tan(Math.toRadians(
                               .replace("log(", "Math.log10(") // 将log(替换为Math.log10(
                               .replace("ln(", "Math.log(");  // 将ln(替换为Math.log(
        
        // 替换平方、倒数和幂符号
        return expression.replace("x²", "^2")                    // 将x²替换为^2
                         .replace("1/x", "1/")                   // 将1/x替换为1/
                         .replace("^", "**");                    // 将^替换为**(JavaScript幂运算)
    }

    private void calculateSquare() {                            // 计算平方
        isShowingTime = false;
        try {
            double value = Double.parseDouble(displayField.getText()); // 解析当前显示的数值
            displayField.setText(String.valueOf(value * value)); // 计算平方并显示结果
        } catch (NumberFormatException e) {
            displayField.setText("计算错误");                       // 处理数字格式异常
        }
    }

    private void calculateReciprocal() {                        // 计算倒数
        isShowingTime = false;
        try {
            double value = Double.parseDouble(displayField.getText()); // 解析当前显示的数值
            if (value == 0) {
                displayField.setText("计算错误");              // 处理除以零的情况
            } else {
                displayField.setText(String.valueOf(1 / value)); // 计算倒数并显示结果
            }
        } catch (NumberFormatException e) {
            displayField.setText("计算错误");                       // 处理数字格式异常
        }
    }

    private void calculateSquareRoot() {                        // 计算平方根
        isShowingTime = false;
        try {
            double value = Double.parseDouble(displayField.getText()); // 解析当前显示的数值
            if (value < 0) {
                displayField.setText("计算错误");        // 处理负数开平方的情况
            } else {
                displayField.setText(String.valueOf(Math.sqrt(value))); // 计算平方根并显示结果
            }
        } catch (NumberFormatException e) {
            displayField.setText("计算错误");                       // 处理数字格式异常
        }
    }

    private void appendFunction(String function) {              // 追加函数
        if (isShowingTime) {
            clearDisplay();
            isShowingTime = false;
        }
        
        String current = displayField.getText();                // 获取当前显示内容
        if (!current.isEmpty() && !isOperator(current.charAt(current.length() - 1))) {
            displayField.setText(current + "*" + function + "("); // 在数字后添加函数时自动插入乘号
        } else {
            displayField.setText(current + function + "(");     // 直接添加函数
        }
    }

    private void generateRandom() {                             // 生成随机数
        isShowingTime = false;
        double randomNum = Math.random();
        displayField.setText(String.format("%.6f", randomNum));
    }

    private void calculateFactorial() {                         // 计算阶乘
        isShowingTime = false;
        try {
            double value = Double.parseDouble(displayField.getText());
            if (value < 0) {
                displayField.setText("计算错误");
                return;
            }
            if (value > 170) {
                displayField.setText("计算错误");
                return;
            }
            long result = 1;
            for (int i = 2; i <= value; i++) {
                result *= i;
            }
            displayField.setText(String.valueOf(result));
        } catch (NumberFormatException e) {
            displayField.setText("计算错误");
        }
    }

    private boolean isOperator(String text) {                    // 判断是否为运算符
        return "+-×÷".contains(text);                             // 检查字符串是否包含运算符
    }
    
    private boolean isOperator(char c) {
        return "+-×÷".indexOf(c) != -1;                          // 检查字符是否为运算符
    }

    private void setupAudio() {                                // 初始化音效系统
        try {
            String soundPath = "D:\\Desk\\见习2\\GOGOGO出发咯_爱给网_aigei_com.wav"; // 音效文件路径
            File soundFile = new File(soundPath);               // 创建文件对象
            if (!soundFile.exists()) {                        // 检查文件是否存在
                System.err.println("错误：音效文件不存在: " + soundPath); // 打印错误信息
                return;
            }
            soundClips.put("custom", loadSound(soundPath));      // 加载音效并存储到映射表
            if (soundClips.get("custom") == null) {              // 检查音效是否加载成功
                System.err.println("警告：自定义音效加载失败，使用默认提示音");
            } else {
                System.out.println("自定义音效加载成功");
            }
        } catch (Exception e) {
            e.printStackTrace();                                // 打印异常堆栈
            System.err.println("音效系统初始化失败");
        }
    }

    private Clip loadSound(String filePath) {                   // 加载音效文件
        try {
            File soundFile = new File(filePath);                // 创建文件对象
            System.out.println("尝试加载音效文件: " + filePath);
            System.out.println("文件大小: " + soundFile.length() + " 字节");
            
            String fileType = filePath.substring(filePath.lastIndexOf('.') + 1).toLowerCase(); // 获取文件扩展名
            if (!"wav".equals(fileType)) {
                System.err.println("警告：推荐使用WAV格式，当前文件类型为: " + fileType);
            }
            
            AudioFileFormat fileFormat = AudioSystem.getAudioFileFormat(soundFile); // 获取音频文件格式
            System.out.println("音频格式: " + fileFormat.getType());
            
            AudioInputStream audioInputStream = AudioSystem.getAudioInputStream(soundFile); // 获取音频输入流
            AudioFormat format = audioInputStream.getFormat(); // 获取音频格式
            
            // 转换为标准PCM格式
            if (format.getEncoding() != AudioFormat.Encoding.PCM_SIGNED) {
                format = new AudioFormat(
                    AudioFormat.Encoding.PCM_SIGNED,
                    format.getSampleRate(),
                    16,
                    format.getChannels(),
                    format.getChannels() * 2,
                    format.getSampleRate(),
                    false
                );
                audioInputStream = AudioSystem.getAudioInputStream(format, audioInputStream); // 转换音频流格式
            }
            
            DataLine.Info info = new DataLine.Info(Clip.class, format); // 创建数据行信息
            if (!AudioSystem.isLineSupported(info)) {
                System.err.println("错误：不支持的音频格式");
                return null;
            }
            
            Clip clip = (Clip) AudioSystem.getLine(info);       // 获取音频剪辑
            clip.open(audioInputStream);                         // 打开音频流
            System.out.println("音效加载成功，时长: " + clip.getMicrosecondLength() / 1000000.0 + " 秒");
            return clip;
        } catch (Exception e) {
            e.printStackTrace();                                // 打印异常堆栈
            return null;
        }
    }

    private void playButtonSound() {                            // 播放按钮音效
        Clip clip = soundClips.get(currentSound);              // 从映射表获取当前音效
        if (clip == null) {
            System.out.println("提示：无可用音效，使用默认反馈");
            Toolkit.getDefaultToolkit().beep();                  // 使用系统默认提示音
            return;
        }
        
        try {
            if (clip.isRunning()) clip.stop();                    // 如果音效正在播放，先停止
            clip.setFramePosition(0);                             // 将播放位置重置为开始
            // 设置音量（降低10分贝）
            FloatControl volume = (FloatControl) clip.getControl(FloatControl.Type.MASTER_GAIN);
            if (volume != null) volume.setValue(-10.0f);           // 设置音量
            
            clip.start();                                        // 开始播放音效
        } catch (Exception e) {
            System.err.println("错误：播放音效失败");
            e.printStackTrace();                                // 打印异常堆栈
            Toolkit.getDefaultToolkit().beep();                  // 使用系统默认提示音
        }
    }
    
    // 启动时钟定时器
    private void startClock() {
        timer = new Timer();
        timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                if (isShowingTime) {
                    SwingUtilities.invokeLater(() -> showTime());
                }
            }
        }, 0, 1000); // 每秒更新一次
    }
    
    // 切换时钟显示状态
    private void toggleClock() {
        isShowingTime = !isShowingTime;
        if (isShowingTime) {
            showTime();
        }
    }

    public static void main(String[] args) {                    // 主方法
        SwingUtilities.invokeLater(Calculator::new);            // 在事件调度线程中创建计算器实例
    }
}